hey @fabianfett I think the goal of not linking foundation is a good one if we cannot get the performance we need with static linking.

I also like the idea of being able to use alternative encoder/decoders, tho overriding encoding/decoding behavior is already possible with the current API, eg:

struct Handler: EventLoopLambdaHandler {
    // the normal handler
    func handle(context: Lambda.Context, payload: Request) -> EventLoopFuture<Response> {
      ...
    }
    
    // override the default encoding behavior
    func encode(allocator: ByteBufferAllocator, value: Response) throws -> ByteBuffer? {
      ...
    }
   
    // override the default decoding behavior
    func decode(buffer: ByteBuffer) throws -> Request {
      ...
    }
}

one idea I did not explore too much and maybe worth looking into is keeping all the Codable APIs in place but allowing the users to inject an alternative TopLevelEncoder/TopLevelDecoder instead of JSONEncoder/JSONDecoder as another way to achieve the override above.

the one thing I am not convinced about is separating the modules like this, it does not feel like a good step from a usability point of view. in practice, I believe most/all invocation use-cases will be JSON based (as shown in #35) which means users are most likely always import AWSLambdaRuntimeFoundationCompat instead of import AWSLambdaRuntime and that seems a bit awkward to me. do you think that most cases will not be JSON based?

@fabianfett as discussed, lets

1. rename AWSLambdaRuntime to AWSLambdaRuntimeCore`
2. rename AWSLambdaRuntimeFoundationCompat to AWSLambdaRuntime
3. have (new) AWSLambdaRuntime export AWSLambdaRuntimeCore

overall looks good but i feel we list allot of testing, is that part of the change necessary?

@tomerd Yes, it is either this, or we make these functions public:

// for testing and internal use
@discardableResult
internal static func run(configuration: Configuration = .init(), handler: Handler) -> Result<Int, Error> {
    self.run(configuration: configuration, factory: { $0.makeSucceededFuture(handler) })
}

// for testing and internal use
@discardableResult
internal static func run(configuration: Configuration = .init(), factory: @escaping (EventLoop) throws -> Handler) -> Result<Int, Error> {
    self.run(configuration: configuration, factory: { eventloop -> EventLoopFuture<Handler> in
        do {
            let handler = try factory(eventloop)
            return eventloop.makeSucceededFuture(handler)
        } catch {
            return eventloop.makeFailedFuture(error)
        }
    })
}